home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / mint / gcc / gcc261a.zoo / info / libobjects < prev   
Encoding:
GNU Info File  |  1994-11-18  |  62.1 KB  |  1,785 lines

  1. This is Info file libobjects.info, produced by Makeinfo-1.55 from the
  2. input file ./libobjects.texi.
  3.  
  4. START-INFO-DIR-ENTRY
  5. * Libobjects::                      The GNU Objective C Class Library.
  6. END-INFO-DIR-ENTRY
  7.  
  8.    This file documents the features and implementation of The GNU
  9. Objective-C class library.
  10.  
  11.    Copyright (C) 1993 Free Software Foundation, Inc.
  12.  
  13.    Permission is granted to make and distribute verbatim copies of this
  14. manual provided the copyright notice and this permission notice are
  15. preserved on all copies.
  16.  
  17.    Permission is granted to copy and distribute modified versions of
  18. this manual under the conditions for verbatim copying, provided also
  19. that the section entitled "GNU Library General Public License" is
  20. included exactly as in the original, and provided that the entire
  21. resulting derived work is distributed under the terms of a permission
  22. notice identical to this one.
  23.  
  24.    Permission is granted to copy and distribute translations of this
  25. manual into another language, under the above conditions for modified
  26. versions, except that the section entitled "GNU Library General Public
  27. License" and this permission notice may be included in translations
  28. approved by the Free Software Foundation instead of in the original
  29. English.
  30.  
  31. File: libobjects.info,  Node: Top,  Next: Copying,  Up: (DIR)
  32.  
  33. Libobjects
  34. **********
  35.  
  36.    This manual documents how to install and use the GNU Objective-C
  37. Class Library (or `libobjects'), version {No Value For
  38. "LIBOBJECTS_VERSION"}, for use with `gcc' version {No Value For
  39. "GCC_VERSION"}.
  40.  
  41.    It is nothing but a skeleton now, mostly containing rough notes.  In
  42. the future it will be fleshed out and the text will be polished.
  43.  
  44. * Menu:
  45.  
  46. * Copying::        GNU Library Public License says how you can copy
  47.                     and share libobjects.
  48. * Contributors::    People who have contributed to libobjects.
  49. * Installation::    How to configure, compile and install libobjects.
  50. * Trouble::         If you have trouble installing libobjects.
  51.  
  52. * Overview::        libobjects in brief.
  53. * Organization::    The heirarchy of protocols and classes.
  54. * Conventions::     Stylistic conventions and design philosophy.
  55. * Content Types::   Collections can contain C types as well as objects.
  56.  
  57. * Creating::        Creating a collection.
  58. * Freeing::         Freeing a collection or its elements.
  59. * Adding::          Adding elements to a collection.
  60. * Removing::        Removing elements from a collection.
  61. * Replacing::       Replacing elements in a collection.
  62. * Enumerating::     Performing an operation with all elements.
  63. * Duplicating::     Making a copy of a collection.
  64. * Archiving::       Writing (and reading) a collection to (from) a file.
  65. * Querying::        Asking questions about a collection and its contents.
  66. * Sorting::         Sorting the contents of a collection.
  67.  
  68. * Classes::         Choosing the class with the features you need.
  69.  
  70. * Projects::        To do list and questions for users.
  71.  
  72. * Protocol Index::
  73. * Class Index::
  74. * Method Function Macro Index::
  75. * Concept Index::
  76.  
  77. File: libobjects.info,  Node: Copying,  Next: Contributors,  Prev: Top,  Up: Top
  78.  
  79. Copying
  80. *******
  81.  
  82.    See the file `COPYING.LIB'.
  83.  
  84. File: libobjects.info,  Node: Contributors,  Next: Installation,  Prev: Copying,  Up: Top
  85.  
  86. Contributors to GNU Objective-C Collection library
  87. **************************************************
  88.  
  89.    * Andrew McCallum <mccallum@gnu.ai.mit.edu> designed the protocol and
  90.      class heirarchies, and wrote the otherwise unattributed classes.
  91.  
  92.    * Kresten Krab Thorup <Kresten_Thorup@NeXT.COM> made libobjects
  93.      possible by writing the GNU Objective-C runtime.  He also
  94.      contributed the GapArray and Storage classes.  He also wrote
  95.      patches to texinfo that make `deftypemethod' possible.
  96.  
  97.    * Adam Fedor <fedor@boulder.colorado.edu> wrote the NXStringTable
  98.      class.
  99.  
  100.    * Paul Kunz <Paul_Kunz@slac.stanford.edu> did a lot to fix the List
  101.      class.
  102.  
  103.    * Kresten Krab Thorup <krab@iesd.auc.dk>, Paul Burchard
  104.      <burchard@geom.umn.edu>, Paul Kunz <Paul_Kunz@slac.stanford.edu>,
  105.      Geoffery Knauth <gsk@marble.com>, Steve Naroff <snaroff@next.com>,
  106.      Richard Stallman <rms@gnu.ai.mit.edu> and others contributed to
  107.      discussions about the library.
  108.  
  109. File: libobjects.info,  Node: Installation,  Next: Trouble,  Prev: Contributors,  Up: Top
  110.  
  111. Installing GNU Objective-C Class Library
  112. ****************************************
  113.  
  114.    To compile and install `libobjects':
  115.  
  116.   1. Install `gcc'.  The library requires gcc version
  117.      2.6.1 or later.
  118.  
  119.   2. Configure the package for your system.  In the directory that this
  120.      file is in, type `./configure'.  If you're using `csh' on an old
  121.      version of System V, you might need to type `sh configure' instead
  122.      to prevent `csh' from trying to execute `configure' itself.
  123.  
  124.      If you are compiling the library for a NeXT machine, you have the
  125.      choice of using either the GNU or the NeXT Objective C runtime.
  126.      You can specify this by setting CFLAGS.  For example:
  127.           CFLAGS=-fgnu-runtime ./configure
  128.  
  129.      The `configure' shell script attempts to guess correct values for
  130.      various system-dependent variables used during compilation, and
  131.      creates the Makefile(s) (one in each subdirectory of the source
  132.      directory).  In some packages it creates a C header file
  133.      containing system-dependent definitions.  It also creates a file
  134.      `config.status' that you can run in the future to recreate the
  135.      current configuration.
  136.  
  137.      Running `configure' takes less than a minute or two.  While it is
  138.      running, it prints some messages that tell what it is doing.  If
  139.      you don't want to see the messages, run `configure' with its
  140.      standard output redirected to `/dev/null'; for example:
  141.           ./configure >/dev/null
  142.  
  143.      To compile the package in a different directory from the one
  144.      containing the source code, you must use a version of make that
  145.      supports the VPATH variable, such as GNU make.  `cd' to the
  146.      directory where you want the object files and executables to go
  147.      and run `configure'.  `configure' automatically checks for the
  148.      source code in the directory that `configure' is in and in `..'.
  149.      If for some reason `configure' is not in the source code directory
  150.      that you are configuring, then it will report that it can't find
  151.      the source code.  In that case, run `configure' with the option
  152.      `--srcdir=DIR', where DIR is the directory that contains the
  153.      source code.
  154.  
  155.      By default, `make install' will install the package's files in
  156.      /usr/local/bin, /usr/local/lib, /usr/local/man, etc.  You can
  157.      specify an installation prefix other than /usr/local by giving
  158.      `configure' the option `--prefix=PATH'.  Alternately, you can do
  159.      so by giving a value for the `prefix' variable when you run
  160.      `make', e.g.,
  161.           make prefix=/usr/gnu
  162.  
  163.      You can specify separate installation prefixes for
  164.      architecture-specific files and architecture-independent files.
  165.      If you give `configure' the option `--exec_prefix=PATH' or set the
  166.      `make' variable `exec_prefix' to PATH, the package will use PATH
  167.      as the prefix for installing programs and libraries.  Data files
  168.      and documentation will still use the regular prefix.  Normally,
  169.      all files are installed using the regular prefix.
  170.  
  171.      You can tell `configure' to figure out the configuration for your
  172.      system, and record it in `config.status', without actually
  173.      configuring the package (creating `Makefile's and perhaps a
  174.      configuration header file).  To do this, give `configure' the
  175.      `--no-create' option.  Later, you can run `./config.status' to
  176.      actually configure the package.  This option is useful mainly in
  177.      `Makefile' rules for updating `config.status' and `Makefile'.  You
  178.      can also give `config.status' the `--recheck' option, which makes
  179.      it re-run `configure' with the same arguments you used before.
  180.      This is useful if you change `configure'.
  181.  
  182.      `configure' ignores any other arguments that you give it.
  183.  
  184.      If your system requires unusual options for compilation or linking
  185.      that `configure' doesn't know about, you can give `configure'
  186.      initial values for some variables by setting them in the
  187.      environment.  In Bourne-compatible shells, you can do that on the
  188.      command line like this:
  189.           CC='gcc -traditional' DEFS=-D_POSIX_SOURCE ./configure
  190.  
  191.      The `make' variables that you might want to override with
  192.      environment variables when running `configure' are:
  193.  
  194.      (For these variables, any value given in the environment overrides
  195.      the value that `configure' would choose:)
  196.     `CC'
  197.           C compiler program.  Default is `cc', or `gcc' if `gcc' is in
  198.           your PATH.
  199.  
  200.     `INSTALL'
  201.           Program to use to install files.  Default is `install' if you
  202.           have it, `install.sh' otherwise.
  203.  
  204.      (For these variables, any value given in the environment is added
  205.      to the value that `configure' chooses:)
  206.     `DEFS'
  207.           Configuration options, in the form `-Dfoo -Dbar ...'
  208.  
  209.     `LIBS'
  210.           Libraries to link with, in the form `-lfoo -lbar ...'
  211.  
  212.      If you need to do unusual things to compile the package, we
  213.      encourage you to figure out how `configure' could check whether to
  214.      do them, and mail diffs or instructions to the address given in
  215.      the `README' so we can include them in the next release.
  216.  
  217.   3. Type `make' to compile the package.  If you want, you can override
  218.      the `make' variables `CFLAGS' and `LDFLAGS' like this:
  219.               make CFLAGS=-O2 LDFLAGS=-s
  220.  
  221.      You will get some warnings from `#warning' lines I've added to the
  222.      code.  Ignore them.
  223.  
  224.      You may get some warnings like `stdobjects.m:0: warning:
  225.      `_OBJC_SELECTOR_TABLE' defined but not used'.  Ignore them.  They
  226.      are bogus warnings due to a bug in cc1obj.
  227.  
  228.      You may get some warnings like `ar: filename BinaryTreeEltNode.o
  229.      truncated to BinaryTreeEltNo'.  Ignore them.
  230.  
  231.   4. If you want to compile the self-tests, cd to `checks' and type
  232.      `make'.  If you want to compile the examples, cd to `examples' and
  233.      type `make'.
  234.  
  235.   5. Type `make install' to install programs, data files, and
  236.      documentation.
  237.  
  238.   6. You can remove the program binaries and object files from the
  239.      source directory by typing `make clean'.  To also remove the
  240.      Makefile(s), and `config.status' (all the files that `configure'
  241.      created), type `make distclean'.
  242.  
  243.      The file `configure.in' is used as a template to create
  244.      `configure' by a program called `autoconf'.  You will only need it
  245.      if you want to regenerate `configure' using a newer version of
  246.      `autoconf'.
  247.  
  248.  
  249. File: libobjects.info,  Node: Trouble,  Next: Overview,  Prev: Installation,  Up: Top
  250.  
  251. Trouble in Installation
  252. ***********************
  253.  
  254.    Try to fix the problem.  Send patches to mccallum@gnu.ai.mit.edu.
  255.  
  256.    <<This section incomplete>>
  257.  
  258. File: libobjects.info,  Node: Overview,  Next: Organization,  Prev: Trouble,  Up: Top
  259.  
  260. Overview
  261. ********
  262.  
  263.    The GNU classes included in this version of the library fall into
  264. five categories: collections, magnitudes, streams, coders and remote
  265. messaging support.
  266.  
  267.    * The collection objects all conform to the `Collecting' protocol.
  268.      Reading `./objects/Collecting.h' is a good place to start.
  269.      Protocols for collections that store their contents with keys and
  270.      with indices can be found in `./objects/KeyedCollecting.h' and
  271.      `./objects/IndexedCollecting.h' respectively.  Examples of generic
  272.      collections are `Set' and `Bag'.  The keyed collections are
  273.      `Dictionary' and `MappedCollector'.  The classes `Array', `Queue',
  274.      `GapArray', `LinkedList', `BinaryTree', `RBTree' and `SplayTree'
  275.      are all indexed collections.
  276.  
  277.    * The useful magnitude classes are `Time' and `Random'.  The
  278.      `Random' class works in conjunction with pseudo-random number
  279.      generators that conform to the `RandomGenerating' protocol.  The
  280.      conforming class `RNGBerkeley' provides identical behavior to the
  281.      BSD random() function.  The class `RNGAdditiveCongruential' is an
  282.      implementation of the additive congruential method.
  283.  
  284.    * Stream objects provide a consistent interface for reading and
  285.      writing bytes.  Read `./objects/Stream.h' to get the general idea.
  286.      `StdioStream' objects work with files, file descriptors, FILE
  287.      pointers and pipes to executables.  `MemoryStream' objects work
  288.      with memory buffers.
  289.  
  290.    * Coders provide a formatted way of writing to Streams.  After a
  291.      coder is initialized with a stream, the coder can encode/decode
  292.      Objective C objects and C types.  See `./objects/Coder.h' for the
  293.      abstract superclass interface; see `./objects/Coding.h' for the
  294.      protocol adopted by objects that read and write themselves using
  295.      coders.  The currently available concrete coders are
  296.      `BinaryCoder', for reading and writing a compact stream of
  297.      illegible bytes, and `TextCoder', for reading and writing
  298.      human-readable text.
  299.  
  300.      Coders and streams can be mixed and matched so that programmers can
  301.      choose the destination and the format separately.
  302.  
  303.      Neither the stream or coder class heirarchies are very mature yet.
  304.      I threw them together because I needed them for remote object
  305.      messaging.
  306.  
  307.    * The remote object messaging support classes are `Connection',
  308.      `Proxy', `ConnectedCoder', `Port' and `SocketPort'.
  309.  
  310. File: libobjects.info,  Node: Organization,  Next: Conventions,  Prev: Overview,  Up: Top
  311.  
  312. Organization
  313. ************
  314.  
  315.    The library is built around several protocols:
  316.  
  317.    * The <Collecting> protocol is root of the collection protocol
  318.      heirarchy.  The <Collecting> protocol defines the most general
  319.      interface to a collection of elements.  Elements can be added,
  320.      removed, and replaced.  The contents can be tested, enumerated,
  321.      and enumerated through various filters.  Elements may be objects,
  322.      or any C type included in the "elt" union given in elt.h, but all
  323.      elements of a collection must be of the same C type.  (For
  324.      examples see Set and Bag.)
  325.  
  326.    * The <KeyedCollecting> protocol inherits from the <Collecting>
  327.      protocol.  The <KeyedCollecting> protocol defines the interface to
  328.      a collection of elements that are accessible by a key, where the
  329.      key is some unique element.  Pairs of (key element, content
  330.      element) may be added, removed and replaced.  The keys and
  331.      contents may be tested, enumerated, and copied.  (For examples see
  332.      Dictionary and MappedCollector.)
  333.  
  334.    * The <IndexedCollecting> protocol inherits from the
  335.      <KeyedCollecting> protocol.  The <IndexedCollecting> protocol
  336.      defines the interface to a collection of elements that are
  337.      accessible by a key that is an index, where the indeces in a
  338.      collection are a contiguous series of unsigned integers beginning
  339.      at 0.  This is the root of the protocol heirarchy for all
  340.      collections that hold their elements in some order.  Elements may
  341.      be accessed, inserted, replaced and removed by their index.  (For
  342.      examples see Array and LinkedList.)
  343.  
  344.    * The <LinkedListComprising> protocol defines the interface to an
  345.      object that may be an element in a LinkedList.  LinkedList is a
  346.      collection object based on a doubly linked list.  (For an example
  347.      see LinkedListNode.)
  348.  
  349.    * The <BinaryTreeComprising> protocol defines the interface to an
  350.      object that may be an element in a BinaryTree.  BinaryTree is a
  351.      collection object based on a binary trees.  (For an example see
  352.      BinaryTreeNode.)
  353.  
  354.    Here is the object inheritance heirarchy.  All collection abtract
  355. superclasses (classes which are not usable without subclassing) end
  356. with "Collection"; all protocols end with "ing"; all collection
  357. protocols end with "Collecting".
  358.  
  359.         Collection <Collecting>
  360.             Set
  361.                 Bag
  362.             KeyedCollection <KeyedCollecting>
  363.                 Dictionary
  364.                 MappedCollector
  365.                 IndexedCollection <IndexedCollecting>
  366.                     Array
  367.                         Stack
  368.                         GapArray
  369.                         CircularArray
  370.                             Queue
  371.                         Heap
  372.                     LinkedList
  373.                     BinaryTree
  374.                     RBTree
  375.                     EltNodeCollector
  376.                     String
  377.          DelegateList
  378.      
  379.          HashTable
  380.          List
  381.          Storage
  382.  
  383.    <<This section unfinished.>>
  384.  
  385. File: libobjects.info,  Node: Conventions,  Next: Content Types,  Prev: Organization,  Up: Top
  386.  
  387. Stylistic Conventions and Design Philosophy
  388. *******************************************
  389.  
  390. Stylistic Conventions
  391. =====================
  392.  
  393.    * Objective-C source files have file extension `.m'. Both
  394.      C-compatibility header files and class declaration files have
  395.      extension `.h'.
  396.  
  397.    * Objective-C class names begin with capital letters.  Multi-word
  398.      class names capitalize each word, with no underscore separation.
  399.  
  400.    * Include files that define Objective-C classes begin with capital
  401.      letters (as do the names of the classes themselves).
  402.  
  403.    * All protocols end with `ing'.  All collection protocols end with
  404.      `Collecting'.  All collection abtract superclasses (classes which
  405.      are not usable without subclassing) end with `Collection'.
  406.  
  407.    * Include files that supply function prototypes for other C
  408.      functions are all lower case.
  409.  
  410.    * Instance variables begin with an underscore, are all lower case,
  411.      and have underscores separating their component words.  The leading
  412.      underscore distinguishes them from local varibles defined inside
  413.      methods.
  414.  
  415.    * All include files define a preprocessor variable __X_h_INCLUDE_GNU,
  416.      where X is the name of the file, and conditionally compile only if
  417.      this has not been already defined.
  418.  
  419.    * The following macros and variables make the relevant version
  420.      numbers available:
  421.  
  422.       - Macro: COLL_VERSION
  423.           The version number of the collection library.  Declared in
  424.           `coll/collstd.h'
  425.  
  426.       - Macro: COLL_GCC_VERSION
  427.           The version number of the compiler used to compile the
  428.           collection library.  Declared in `coll/collstd.h'
  429.  
  430.       - Variable: char[] coll_version
  431.           A string containing the version number of the collection
  432.           library.  Declared in `coll/collstd.h'
  433.  
  434.       - Variable: char[] coll_gcc_version
  435.           A string containing the version number of the compiler used
  436.           to compile the collection library.  Declared in
  437.           `coll/collstd.h'
  438.  
  439. The design philosophy.
  440. ======================
  441.  
  442.    Objective-C is not Smalltalk.  Differences that matter to the
  443. Collection heirarchy:
  444.  
  445.    * There can be only one set of argument types with each selector.
  446.      (For instance in Objective-C we can't have "-(double)data" and
  447.      "-(char)data".  I can't stand it when some library that I'm forced
  448.      to load already defines a selector that I want to use with
  449.      different types.)  This isn't an issue in Smalltalk because
  450.      everything is an object.
  451.  
  452.      I make the Collection method names a little more descriptive, while
  453.      keeping them close to Smalltalk.  (For instance I think there is a
  454.      good reason for using "-addObject:" instead of "-add:")
  455.  
  456.    * We will want collections of int's, float's, and other non-Objects.
  457.      Using Objective C wrappers around these C primitive types (i.e.
  458.      Integer and Float objects) is not an efficient enough option for
  459.      all cases.
  460.  
  461.      We could create two parallel heirarchies, one for Objects and one
  462.      for elements passed as void*, but since so much of the
  463.      functionality overlaps, I have merged them, and it doesn't
  464.      actually look all that bad.
  465.  
  466.    * Objective C doesn't have Smalltalk Blocks.
  467.  
  468.      Passing pointers to functions is a reasonable substitute.  This is
  469.      made easier with gcc's nested functions and the LAMBDA() macro
  470.      defined in coll/collstd.h.
  471.  
  472.    * Smalltalk does automatic garbage collection; Objective C doesn't.
  473.  
  474.      I think it should be made obvious which methods allocate a new
  475.      object.  Hence "-shallowCopyAs:[Bag class]" instead of "as:[Bag
  476.      class]".
  477.  
  478.    * We have usable Collection classes (Set, Bag, Array, etc) with
  479.      functionality matching Smalltalk's objects, but there are good
  480.      reasons for not having the abstract superclass structure match
  481.      Smalltalk exactly.
  482.  
  483.    <<This section unfinished.>>
  484.  
  485. File: libobjects.info,  Node: Content Types,  Next: Creating,  Prev: Conventions,  Up: Top
  486.  
  487. Content types
  488. *************
  489.  
  490.    Collections can hold either objects or primitive C types.  More
  491. specifically, collections can hold any of the types in the `elt' union
  492. defined in `coll/elt.h'.  All contents of a collection must be of the
  493. same type.
  494.  
  495.    You declare which type the collection will hold at collection
  496. initialization time, and the type can not be changed later.  You
  497. specify the type using the Objective-C `@encode()' directive.  You can
  498. find out the type held by a collection with the method
  499. `contentEncoding' (*note Querying::.).
  500.  
  501.    Many operations are independent of the type the collection holds.
  502. For example the method `-(unsigned)count' returns the number of members
  503. in the collection.
  504.  
  505.    Other operations need to take arguments of different types depending
  506. on whether the contents are objects or some other type.  In this case
  507. there will be two methods, distinguished by the words `Object' and
  508. `Element' in their method name.  For example, `-removeObject:anObject'
  509. vs `-(elt)removeElement:(elt)anElement'.
  510.  
  511.    <<Unfinished.>>
  512.  
  513. File: libobjects.info,  Node: Creating,  Next: Freeing,  Prev: Content Types,  Up: Top
  514.  
  515. Creating a Collection
  516. *********************
  517.  
  518. * Menu:
  519.  
  520. * Basic Creating::
  521. * Keyed Creating::
  522.  
  523. File: libobjects.info,  Node: Basic Creating,  Next: Keyed Creating,  Up: Creating
  524.  
  525. Basic Creating
  526. ==============
  527.  
  528.  - Method on Collection:  -init
  529.  
  530.  - Method on Collection:  -initEncoding: (const char *)CONTENTENCODING
  531.  
  532.    Create with `alloc' and `init'.  Specify the type of contents using
  533. `initEncoding:'.  For example:
  534.  
  535.      id arrayHoldingInts = [[Array alloc] initEncoding:@encode(int)];
  536.  
  537.    <<This section unfinished.>>
  538.  
  539. File: libobjects.info,  Node: Keyed Creating,  Prev: Basic Creating,  Up: Creating
  540.  
  541. Keyed Creating
  542. ==============
  543.  
  544. File: libobjects.info,  Node: Freeing,  Next: Adding,  Prev: Creating,  Up: Top
  545.  
  546. Freeing a Collection or its Elements
  547. ************************************
  548.  
  549.    You can free all the objects in a collection and empty it using
  550. `freeObjects'.  You can emtpy a collection without freeing the contents
  551. using `empty'.  You can free a collection without freeing the contents
  552. using `free'.
  553.  
  554.    <<This section unfinished.>>
  555.  
  556. File: libobjects.info,  Node: Adding,  Next: Removing,  Prev: Freeing,  Up: Top
  557.  
  558. Adding Elements to a Collection
  559. *******************************
  560.  
  561.    Talk about adding.
  562.  
  563. * Menu:
  564.  
  565. * Basic Adding::
  566. * Keyed Adding::
  567. * Indexed Adding::
  568.  
  569. File: libobjects.info,  Node: Basic Adding,  Next: Keyed Adding,  Up: Adding
  570.  
  571. Basic Adding
  572. ============
  573.  
  574.    Adding, adding if absent, adding a copy, adding all contents of
  575. another collection, adding contents if absent, adding with varargs.
  576.  
  577.  - Method on Collection:  -addObject: NEWOBJECT
  578.  - Method on Collection:  -addElement: (elt)NEWELEMENT
  579.      Adds NEWOBJECT to the receiving collection.  Returns self.
  580.  
  581.  - Method on Collection:  -addObjectIfAbsent: NEWOBJECT
  582.  - Method on Collection:  -addElementIfAbsent: (elt)NEWELEMENT
  583.      Adds NEWOBJECT to the receiving collection only if NEWOBJECT isn't
  584.      there already.  Returns self.
  585.  
  586.  - Method on Collection:  -addContentsOf: (id <Collecting>)NEWOBJECT
  587.      Adds all the elements in ACOLLECTION to the receiving collection.
  588.      Returns self.
  589.  
  590.  - Method on Collection:  -addContentsOfIfAbsent: (id
  591.           <Collecting>)NEWOBJECT
  592.      <<Undocumented>>  Returns self.
  593.  
  594.  - Method on Collection:  -addObjectsCount: (unsigned)COUNT, ...
  595.  - Method on Collection:  -addElementsCount: (unsigned)COUNT, ...
  596.      <<Undocumented>>  Returns self.
  597.  
  598.      Here is an example
  599.           id o1 = [[Foo alloc] init];
  600.           id o2 = [[Bar alloc] init];
  601.           id myArray = [[[Array alloc] init] addObjectsCount: 2, o1, o2];
  602.  
  603. File: libobjects.info,  Node: Keyed Adding,  Next: Indexed Adding,  Prev: Basic Adding,  Up: Adding
  604.  
  605. Keyed Adding
  606. ============
  607.  
  608.    If the collection's contents are accessible by a key, members can be
  609. inserted at a specified key.  See KeyedCollecting protocol.
  610.  
  611.  - Method on KeyedCollection:  -insertObject: NEWCONTENTOBJECT atKey:
  612.           (elt)AKEY
  613.  - Method on KeyedCollection:  -insertElement: (elt)NEWCONTENTELEMENT
  614.           atKey: (elt)AKEY
  615.      <<Undocumented>>  returns self.
  616.  
  617. File: libobjects.info,  Node: Indexed Adding,  Prev: Keyed Adding,  Up: Adding
  618.  
  619. Indexed Adding
  620. ==============
  621.  
  622.    Furthermore, if the collections contents are accessible by an index
  623. (an unsigned integer key), members can be appended, prepended.  Inserted
  624. members push other members down to make room.  See IndexedCollecting
  625. protocol.
  626.  
  627.  - Method on IndexedCollection:  -insertObject: NEWOBJECT atIndex:
  628.           (unsigned)INDEX
  629.  - Method on IndexedCollecting:  -insertElement: (elt)NEWELEMENT
  630.           atIndex: (unsigned)INDEX
  631.      <<Undocumented>>  returns self.
  632.  
  633.  - Method on IndexedCollection:  -insertObject: NEWOBJECT before:
  634.           OLDOBJECT
  635.  - Method on IndexedCollecting:  -insertElement: (elt)NEWELEMENT
  636.           before: OLDOBJECT
  637.      <<Undocumented>>  returns self.
  638.  
  639.  - Method on IndexedCollection:  -insertObject: NEWOBJECT after:
  640.           OLDOBJECT
  641.  - Method on IndexedCollecting:  -insertElement: (elt)NEWELEMENT after:
  642.           OLDOBJECT
  643.      <<Undocumented>>  returns self.
  644.  
  645.  - Method on IndexedCollection:  insertContentsOf: (id
  646.           <Collecting>)ACOLLECTION atIndex: (unsigned)INDEX
  647.      <<Undocumented>>  returns self.
  648.  
  649.  - Method on IndexedCollection:  -appendObject: NEWOBJECT
  650.  - Method on IndexedCollecting:  -appendElement: (elt)NEWELEMENT
  651.  - Method on IndexedCollection:  -prependObject: NEWOBJECT
  652.  - Method on IndexedCollecting:  -prependElement: (elt)NEWELEMENT
  653.      <<Undocumented>>  returns self.
  654.  
  655.  - Method on IndexedCollection:  -appendContentsOf: (id
  656.           <Collecting>)ACOLLECTION
  657.  - Method on IndexedCollection:  -prependContentsOf: (id
  658.           <Collecting>)ACOLLECTION
  659.      <<Undocumented>>  returns self.
  660.  
  661.    <<This section unfinished.>>
  662.  
  663. File: libobjects.info,  Node: Removing,  Next: Replacing,  Prev: Adding,  Up: Top
  664.  
  665. Removing Elements from a Collection
  666. ***********************************
  667.  
  668.    About removing...
  669.  
  670. * Menu:
  671.  
  672. * Basic Removing::
  673. * Keyed Removing::
  674. * Indexed Removing::
  675.  
  676. File: libobjects.info,  Node: Basic Removing,  Next: Keyed Removing,  Up: Removing
  677.  
  678. File: libobjects.info,  Node: Keyed Removing,  Next: Indexed Removing,  Prev: Basic Removing,  Up: Removing
  679.  
  680. File: libobjects.info,  Node: Indexed Removing,  Prev: Keyed Removing,  Up: Removing
  681.  
  682.    <<This section unfinished.>>
  683.  
  684. File: libobjects.info,  Node: Replacing,  Next: Enumerating,  Prev: Removing,  Up: Top
  685.  
  686. Replacing Elements in a Collection
  687. **********************************
  688.  
  689. * Menu:
  690.  
  691. * Basic Replacing::
  692. * Keyed Replacing::
  693. * Indexed Replacing::
  694.  
  695. File: libobjects.info,  Node: Basic Replacing,  Next: Keyed Replacing,  Up: Replacing
  696.  
  697. File: libobjects.info,  Node: Keyed Replacing,  Next: Indexed Replacing,  Prev: Basic Replacing,  Up: Replacing
  698.  
  699. File: libobjects.info,  Node: Indexed Replacing,  Prev: Keyed Replacing,  Up: Replacing
  700.  
  701.    <<This section unfinished.>>
  702.  
  703. File: libobjects.info,  Node: Enumerating,  Next: Duplicating,  Prev: Replacing,  Up: Top
  704.  
  705. Enumerating the Contents of a Collection
  706. ****************************************
  707.  
  708.    Enumeration methods allow you to perform a specified operation on the
  709. members of a collection.  You can operate on all the members, operate on
  710. all the members until a flag is set, operate only on the members that
  711. pass some test, or operate on the results of passing the members through
  712. a modifying function.  Each of the enumerators come in pairs: one method
  713. for enumerating in place, and another method that is "safe" for
  714. enumerating when the operation changes the contents of the receiving
  715. collection.  If the contents of the collection are changed during the
  716. enumeration you must use the "safe" methods.
  717.  
  718. * Menu:
  719.  
  720. * Safe vs Unsafe Enumerating::  Enumerations while changing the contents
  721.  
  722. * Basic Enumerating::           Enumerations available for all collections
  723. * Keyed Enumerating::           Enumerations on collections with keys
  724. * Indexed Enumerating::         Enumerations on ordered collections
  725.  
  726. * LAMBDA::                      Defining functions in place with LAMBDA()
  727.  
  728. File: libobjects.info,  Node: Safe vs Unsafe Enumerating,  Next: Basic Enumerating,  Up: Enumerating
  729.  
  730. Safe vs Unsafe Enumerating
  731. ==========================
  732.  
  733.    The simple enumerators operate on the collection in-place.  If the
  734. contents of the collection change during the enumeration, you must use
  735. the "safe" version of the enumerator instead.
  736.  
  737.    It works by making a shallow copy of the receiver, performing the
  738. enumeration using the shallow copy, then freeing the shallow copy.
  739.  
  740.    All enumerators have both "safe" and plain versions.
  741.  
  742.    <<This section unfinished.>>
  743.  
  744. File: libobjects.info,  Node: Basic Enumerating,  Next: Keyed Enumerating,  Prev: Safe vs Unsafe Enumerating,  Up: Enumerating
  745.  
  746. Basic Enumerating
  747. =================
  748.  
  749.    The most basic enumerator is
  750.  
  751.  - Method on Collection:  -withObjectsCall: (void(*)(id))FUNC
  752.  - Method on Collection:  -safeWithObjectsCall: (void(*)(id))FUNC
  753.  - Method on Collection:  -withElementsCall: (void(*)(elt))FUNC
  754.  - Method on Collection:  -safeWithElementsCall: (void(*)(elt))FUNC
  755.      Calls the function FUNC with each the members of the collection.
  756.      Returns self.
  757.  
  758.  - Method on Collection: (void*) -newEnumState
  759.  
  760.  - Method on Collection:  -freeEnumState: (void**)ENUMSTATEPTR
  761.  
  762.  - Method on Collection: (BOOL) -getNextObject: (id *)ANOBJECTPTR
  763.           withEnumState: (void**)ENUMSTATE
  764.  - Method on Collection: (BOOL) -getNextElement: (elt *)ANELEMENTPTR
  765.           withEnumState: (void**)ENUMSTATE
  766.  
  767.      void print_first_difference (id coll1, id coll2)
  768.        {
  769.          void *enumState1, *enumState2;
  770.          id object1, object2;
  771.      
  772.          enumState1 = [coll1 newEnumState];
  773.          enumState2 = [coll2 newEnumState];
  774.          while ([coll1 getNextObject:&object1 withEnumState:&enumState1]
  775.                 && [coll2 getNextObject:&object2 withEnumState:&enumState2])
  776.            {
  777.              if ([object1 compare:object2])
  778.                {
  779.                  [object1 printForDebugger];
  780.                  [object2 printForDebugger];
  781.                }
  782.            }
  783.          [coll1 freeEnumState:&enumState1];
  784.          [coll2 freeEnumState:&enumState2];
  785.        }
  786.  
  787.  - Method on Collection:  -withElementsCall: (void(*)(elt))AFUNC
  788.           whileTrue: (BOOL*)FLAG
  789.  - Method on Collection:  -safeWithElementsCall: (void(*)(elt))AFUNC
  790.           whileTrue: (BOOL*)FLAG
  791.  
  792. File: libobjects.info,  Node: Keyed Enumerating,  Next: Indexed Enumerating,  Prev: Basic Enumerating,  Up: Enumerating
  793.  
  794. Keyed Enumerating
  795. =================
  796.  
  797. File: libobjects.info,  Node: Indexed Enumerating,  Next: LAMBDA,  Prev: Keyed Enumerating,  Up: Enumerating
  798.  
  799. Indexed Enumerating
  800. ===================
  801.  
  802.  - Method on IndexedCollection: (BOOL) -getPrevObject: (id *)
  803.           ANOBJECTPTR withEnumState: (void**)ENUMSTATE
  804.  - Method on IndexedCollection: (BOOL) -getPrevElement: (elt *)
  805.           ANELEMENTPTR withEnumState: (void**)ENUMSTATE
  806.  
  807.  - Method on IndexedCollection:  -withObjectsInReverseCall:
  808.           (void(*)(id))AFUNC
  809.  - Method on IndexedCollection:  -safeWithObjectsInReverseCall:
  810.           (void(*)(id))AFUNC
  811.  - Method on IndexedCollection:  -withElementsInReverseCall:
  812.           (void(*)(elt))AFUNC
  813.  - Method on IndexedCollection:  -safeWithElementsInReverseCall:
  814.           (void(*)(elt))AFUNC
  815.  
  816.  - Method on IndexedCollection:  -withObjectsInReverseCall:
  817.           (void(*)(id)) AFUNC whileTrue: (BOOL *)FLAG
  818.  - Method on IndexedCollection:  -safeWithObjectsInReverseCall:
  819.           (void(*)(id)) AFUNC whileTrue: (BOOL *)FLAG
  820.  - Method on IndexedCollection:  -withElementsInReverseCall:
  821.           (void(*)(elt)) AFUNC whileTrue: (BOOL *)FLAG
  822.  - Method on IndexedCollection:  -safeWithElementsInReverseCall:
  823.           (void(*)(elt)) AFUNC whileTrue: (BOOL *)FLAG
  824.  
  825.  - Method on IndexedCollection:  -makeObjectsPerformInReverse: (SEL)
  826.           ASEL
  827.  - Method on IndexedCollection:  -safeMakeObjectsPerformInReverse:
  828.           (SEL) ASEL
  829.  - Method on IndexedCollection:  -makeObjectsPerformInReverse: (SEL)
  830.           ASEL with: ARGOBJECT
  831.  - Method on IndexedCollection:  -safeMakeObjectsPerformInReverse:
  832.           (SEL) ASEL with: ARGOBJECT
  833.  
  834. File: libobjects.info,  Node: LAMBDA,  Prev: Indexed Enumerating,  Up: Enumerating
  835.  
  836. Defining Functions In Place with LAMBDA()
  837. =========================================
  838.  
  839.    NOTE:  The LAMBDA macro does not work on all systems.  We are waiting
  840. for a general fix.  You should avoid using it until then.
  841.  
  842.    There may not already be a function that does the operation you want
  843. performed during an enumeration.  In this case you will have to write
  844. such a function yourself.
  845.  
  846.    If the function will be used more than once, you should write it as C
  847. functions are usually defined.  However, if the function will only be
  848. used for this one enumeration and the function is small, using the
  849. `LAMBDA' macro may be easier and more clear.
  850.  
  851.  - Macro: LAMBDA(RETTYPE, ARGS, BODY)
  852.      `LAMBDA' is a macro for defining a nested function and returning a
  853.      pointer to that function.  You can use `LAMBDA' wherever a
  854.      function pointer is required.  RETTYPE is the C type returned by
  855.      the function.  ARGS is the parenthesis-enclosed list of arguments
  856.      to the function.  (Declare them just like in an ANSI function
  857.      definition.)  BODY is the curly-bracket-enclosed body of the
  858.      function.
  859.  
  860.      For example, you could create a pointer to a function that adds its
  861.      arguments like this:
  862.           LAMBDA(int, (int a, int b), {return a + b;})
  863.  
  864.    `LAMBDA' is particularly convenient for enumeration methods because
  865. the macro can be placed in the position of the method argument.  For
  866. instance, you can write:
  867.        - fooMethod
  868.        {
  869.          id newColl;
  870.          ...
  871.          newColl = [self emptyCopyAs:[Array class]];
  872.          [self withObjectsCall:
  873.                LAMBDA(void, (id o), {[newColl addObject:[o copy]];})];
  874.          return self;
  875.        }
  876.    instead of writing:
  877.        - fooMethod
  878.        {
  879.          id newColl = [self emptyCopyAs:[Array class]];
  880.          void myTmpFunc(id o)
  881.            {
  882.              [newColl addObject:[o copy]];
  883.            }
  884.          ...
  885.          [self withObjectsCall:myTmpFunc];
  886.          return self;
  887.        }
  888.    In these examples, there may be many lines of code between the
  889. declarations at the top of the method and the `withObjectsCall:' at the
  890. bottom of the method.  Using `LAMBDA' allows you to declare the
  891. function where it is used, instead of arbitrarily far from where it is
  892. used.
  893.  
  894.    The name `LAMBDA' comes from lambda calculus and LISP.
  895.  
  896.    The `LAMBDA' macro and some similar macros are defined in
  897. `coll/collstd.h'.
  898.  
  899. Filtered Enumerating
  900. ====================
  901.  
  902. Enumerating with Keyed Collections
  903. ==================================
  904.  
  905. Enumerating with Indexed Collections
  906. ====================================
  907.  
  908.    <<This section unfinished.>>
  909.  
  910. File: libobjects.info,  Node: Duplicating,  Next: Archiving,  Prev: Enumerating,  Up: Top
  911.  
  912. Duplicating
  913. ***********
  914.  
  915.    Talk about shallow and deep copies.
  916.  
  917.    <<This section unfinished.>>
  918.  
  919. File: libobjects.info,  Node: Archiving,  Next: Querying,  Prev: Duplicating,  Up: Top
  920.  
  921. Archiving
  922. *********
  923.  
  924.    You can write collections to a stream.  You can read them back in
  925. again.  Talk about the `-awake' method.
  926.  
  927.  - Method on Collection:  -write: (TypedStream*)ASTREAM
  928.      <<Undocumented>>  Returns self.
  929.  
  930.  - Method on Collection:  -read: (TypedStream*)ASTREAM
  931.      <<Undocumented>>  Returns self.
  932.  
  933.    <<This section unfinished.>>
  934.  
  935. File: libobjects.info,  Node: Querying,  Next: Sorting,  Prev: Archiving,  Up: Top
  936.  
  937. Querying
  938. ********
  939.  
  940.    <<This section unfinished.>>
  941.  
  942. * Menu:
  943.  
  944. * Basic Querying::
  945. * Keyed Querying::
  946. * Indexed Querying::
  947.  
  948. File: libobjects.info,  Node: Basic Querying,  Next: Keyed Querying,  Up: Querying
  949.  
  950. Basic Querying
  951. ==============
  952.  
  953.  - Method on Collection: (BOOL) -isEmpty
  954.      Returns YES if the receiver contains no members; returns NO
  955.      otherwise.
  956.  
  957.  - Method on Collection: (const char *) -contentEncoding
  958.      Returns a description of the C type that the receiving collection
  959.      can hold.  The description is a string of the form returned by the
  960.      Objective-C `@encode' directive.
  961.  
  962. File: libobjects.info,  Node: Keyed Querying,  Next: Indexed Querying,  Prev: Basic Querying,  Up: Querying
  963.  
  964. Keyed Querying
  965. ==============
  966.  
  967. File: libobjects.info,  Node: Indexed Querying,  Prev: Keyed Querying,  Up: Querying
  968.  
  969. Indexed Querying
  970. ================
  971.  
  972. File: libobjects.info,  Node: Sorting,  Next: Classes,  Prev: Querying,  Up: Top
  973.  
  974. Sorting
  975. *******
  976.  
  977.    <<This section unfinished.>>
  978.  
  979. File: libobjects.info,  Node: Classes,  Next: Projects,  Prev: Sorting,  Up: Top
  980.  
  981. Choosing the Right Class
  982. ************************
  983.  
  984.    Talk about keys or no keys, ordered or not ordered.  Talk about the
  985. classes the require protocol-conforming objects as members.
  986.  
  987. * Menu:
  988.  
  989. * Set::
  990. * Bag::
  991.  
  992. * Dictionary::
  993. * MappedCollector::
  994.  
  995. * Array::
  996. * Stack::
  997. * Queue::
  998. * GapArray::
  999.  
  1000. * LinkedList::
  1001. * BinaryTree::
  1002. * RBTree::
  1003. * SplayTree::
  1004. * EltNodeCollector::
  1005.  
  1006. * Collection::
  1007. * KeyedCollection::
  1008. * IndexedCollection::
  1009.  
  1010.    <<This section unfinished.>>
  1011.  
  1012. File: libobjects.info,  Node: Set,  Next: Bag,  Up: Classes
  1013.  
  1014. Set
  1015. ===
  1016.  
  1017.    <<This section unfinished.>>
  1018.  
  1019. File: libobjects.info,  Node: Bag,  Next: Dictionary,  Prev: Set,  Up: Classes
  1020.  
  1021. Bag
  1022. ===
  1023.  
  1024.    A Bag is ...
  1025.  
  1026. * Menu:
  1027.  
  1028. * Basic Creating::
  1029. * Freeing::
  1030. * Bag Adding::
  1031. * Basic Adding::
  1032. * Keyed Adding::
  1033. * Indexed Adding::
  1034. * Bag Removing::
  1035. * Basic Removing::
  1036. * Keyed Removing::
  1037. * Indexed Removing::
  1038. * Basic Removing::
  1039. * Keyed Removing::
  1040. * Indexed Removing::
  1041. * Basic Enumerating::
  1042. * Keyed Enumerating::
  1043. * Indexed Enumerating::
  1044.  
  1045. File: libobjects.info,  Node: Bag Adding,  Next: Bag Removing,  Up: Bag
  1046.  
  1047.  - Method on Bag:  -addObject: NEWOBJECT withOccurrences:
  1048.           (unsigned)COUNT
  1049.  - Method on Bag:  -addElement: (elt)NEWELEMENT withOccurrences:
  1050.           (unsigned)COUNT
  1051.  
  1052. File: libobjects.info,  Node: Bag Removing,  Prev: Bag Adding,  Up: Bag
  1053.  
  1054.  - Method on Bag:  -removeObject: OLDOBJECT occurrences: (unsigned)COUNT
  1055.  - Method on Bag:  -removeElement: (elt)OLDELEMENT occurrences:
  1056.           (unsigned)COUNT
  1057.  
  1058.    <<This section unfinished.>>
  1059.  
  1060. File: libobjects.info,  Node: Dictionary,  Next: MappedCollector,  Prev: Bag,  Up: Classes
  1061.  
  1062. Dictionary
  1063. ==========
  1064.  
  1065.    A Dictionary is ...
  1066.  
  1067. File: libobjects.info,  Node: MappedCollector,  Next: Array,  Prev: Dictionary,  Up: Classes
  1068.  
  1069. MappedCollector
  1070. ===============
  1071.  
  1072.    A MappedCollector is ...
  1073.  
  1074. File: libobjects.info,  Node: Array,  Next: Stack,  Prev: MappedCollector,  Up: Classes
  1075.  
  1076. Array
  1077. =====
  1078.  
  1079.    An Array is ...
  1080.  
  1081. * Menu:
  1082.  
  1083. * Array Capacity Management::
  1084. * Basic Creating::
  1085. * Freeing::
  1086. * Basic Adding::
  1087. * Keyed Adding::
  1088. * Indexed Adding::
  1089. * Basic Removing::
  1090. * Keyed Removing::
  1091. * Indexed Removing::
  1092. * Basic Replacing::
  1093. * Keyed Replacing::
  1094. * Indexed Replacing::
  1095. * Basic Enumerating::
  1096. * Keyed Enumerating::
  1097. * Indexed Enumerating::
  1098. * Duplicating::
  1099. * Archiving::
  1100. * Basic Querying::
  1101. * Keyed Querying::
  1102. * Indexed Querying::
  1103.  
  1104. File: libobjects.info,  Node: Array Capacity Management,  Up: Array
  1105.  
  1106. Array Methods
  1107. =============
  1108.  
  1109.  - Method on Array: (unsigned) +defaultCapacity
  1110.  
  1111.  - Method on Array: (unsigned) +defaultGrowFactor
  1112.  
  1113.  - Method on Array:  -initEncoding: (const char *)
  1114.      CONTENTENCODING capacity: (unsigned) ACAPACITY
  1115.  
  1116.  
  1117.  - Method on Array:  -setCapacity: (unsigned) NEWCAPACITY
  1118.  
  1119.  - Method on Array:  -setGrowFactor: (unsigned) ANUM
  1120.  
  1121. File: libobjects.info,  Node: Stack,  Next: Queue,  Prev: Array,  Up: Classes
  1122.  
  1123. Stack
  1124. =====
  1125.  
  1126. * Menu:
  1127.  
  1128. * Stack Methods::
  1129. * Array Capacity Management::
  1130. * Basic Creating::
  1131. * Freeing::
  1132. * Basic Adding::
  1133. * Keyed Adding::
  1134. * Indexed Adding::
  1135. * Basic Removing::
  1136. * Keyed Removing::
  1137. * Indexed Removing::
  1138. * Basic Replacing::
  1139. * Keyed Replacing::
  1140. * Indexed Replacing::
  1141. * Basic Enumerating::
  1142. * Keyed Enumerating::
  1143. * Indexed Enumerating::
  1144. * Duplicating::
  1145. * Archiving::
  1146. * Basic Querying::
  1147. * Keyed Querying::
  1148. * Indexed Querying::
  1149.  
  1150. File: libobjects.info,  Node: Stack Methods,  Up: Stack
  1151.  
  1152.  - Method on Stack:  -pushObject: NEWOBJECT
  1153.  - Method on Stack:  -pushElement: (elt)NEWELEMENT
  1154.  
  1155.  - Method on Stack:  -popObject: NEWOBJECT
  1156.  - Method on Stack:  -popElement: (elt)NEWELEMENT
  1157.  
  1158.  - Method on Stack:  -topObject
  1159.  - Method on Stack: (elt) -topElement
  1160.  
  1161.  - Method on Stack:  -exchangeTop
  1162.  
  1163. File: libobjects.info,  Node: Queue,  Next: GapArray,  Prev: Stack,  Up: Classes
  1164.  
  1165. File: libobjects.info,  Node: GapArray,  Next: LinkedList,  Prev: Queue,  Up: Classes
  1166.  
  1167. File: libobjects.info,  Node: LinkedList,  Next: BinaryTree,  Prev: GapArray,  Up: Classes
  1168.  
  1169. File: libobjects.info,  Node: BinaryTree,  Next: RBTree,  Prev: LinkedList,  Up: Classes
  1170.  
  1171. File: libobjects.info,  Node: RBTree,  Next: SplayTree,  Prev: BinaryTree,  Up: Classes
  1172.  
  1173. File: libobjects.info,  Node: SplayTree,  Next: EltNodeCollector,  Prev: RBTree,  Up: Classes
  1174.  
  1175. File: libobjects.info,  Node: EltNodeCollector,  Next: Collection,  Prev: SplayTree,  Up: Classes
  1176.  
  1177. File: libobjects.info,  Node: Collection,  Next: KeyedCollection,  Prev: EltNodeCollector,  Up: Classes
  1178.  
  1179.    A Collection is ...
  1180.  
  1181. * Menu:
  1182.  
  1183. * Basic Creating::
  1184. * Freeing::
  1185. * Basic Adding::
  1186. * Basic Removing::
  1187. * Basic Replacing::
  1188. * Basic Enumerating::
  1189. * Duplicating::
  1190. * Archiving::
  1191. * Basic Querying::
  1192.  
  1193. File: libobjects.info,  Node: KeyedCollection,  Next: IndexedCollection,  Prev: Collection,  Up: Classes
  1194.  
  1195. KeyedCollection
  1196. ===============
  1197.  
  1198. * Menu:
  1199.  
  1200. * Basic Creating::
  1201. * Keyed Creating::
  1202. * Freeing::
  1203. * Basic Adding::
  1204. * Keyed Adding::
  1205. * Basic Removing::
  1206. * Keyed Removing::
  1207. * Basic Replacing::
  1208. * Keyed Replacing::
  1209. * Basic Enumerating::
  1210. * Keyed Enumerating::
  1211. * Duplicating::
  1212. * Archiving::
  1213. * Basic Querying::
  1214. * Keyed Querying::
  1215.  
  1216. File: libobjects.info,  Node: IndexedCollection,  Prev: KeyedCollection,  Up: Classes
  1217.  
  1218. IndexedCollection
  1219. =================
  1220.  
  1221. * Menu:
  1222.  
  1223. * Basic Creating::
  1224. * Freeing::
  1225. * Basic Adding::
  1226. * Keyed Adding::
  1227. * Indexed Adding::
  1228. * Basic Removing::
  1229. * Keyed Removing::
  1230. * Indexed Removing::
  1231. * Basic Replacing::
  1232. * Keyed Replacing::
  1233. * Indexed Replacing::
  1234. * Basic Enumerating::
  1235. * Keyed Enumerating::
  1236. * Indexed Enumerating::
  1237. * Duplicating::
  1238. * Archiving::
  1239. * Basic Querying::
  1240. * Keyed Querying::
  1241. * Indexed Querying::
  1242.  
  1243. File: libobjects.info,  Node: Projects,  Next: Protocol Index,  Prev: Classes,  Up: Top
  1244.  
  1245. To Do List and Questions
  1246. ************************
  1247.  
  1248. Projects Looking for Volunteers
  1249. ===============================
  1250.  
  1251.    If you think you can do one of these projects, please let me know.
  1252. Your help is greatly appreciated!  Send email to
  1253. `mccallum@gnu.ai.mit.edu'.
  1254.  
  1255.    * Make the GNU Objective C runtime properly initialize the class
  1256.      pointer of statically-created string objects (i.e. the string
  1257.      objects created with the syntax `@"This is a constant string
  1258.      object"').  See the relevant comments in gcc/objc-act.c.  Once we
  1259.      get this working I'll release the suite of String classes that
  1260.      I've already written.
  1261.  
  1262.      Please!  Someone?  I want to do this soon so that we can get the
  1263.      ensuing interface changes done before too many people write code
  1264.      based on the current deprecated char-pointer interfaces.
  1265.  
  1266.    * Make the GNU Objective C runtime thread-safe.  (Again, someone?
  1267.      We really need this.)
  1268.  
  1269.    * Write a test-suite for the library.  Use dejagnu.
  1270.  
  1271.    * Write a proper name server for SocketPort's.  Currently we're just
  1272.      hashing the name to a socket port number--we could get unwanted
  1273.      hash collisions.  This will also allow us to name a SocketPort
  1274.      after it's been created.
  1275.  
  1276.    * Make SocketPort more reliable than UDP.
  1277.  
  1278.    * Add some features to the compiler:
  1279.        1. You can't add __attribute__'s to methods.  I want to use:
  1280.                   - (int) writeFormat: (const char *)format, ...
  1281.                       __attribute__ ((format (printf, 1, 2)));
  1282.                   - (int) readFormat: (const char *)format, ...
  1283.                       __attribute__ ((format (scanf, 1, 2)));
  1284.  
  1285.        2. I would like to be able to use a function name/pointer as an
  1286.           argument to @encode() and get a type string like the selector
  1287.           types.
  1288.  
  1289.    * Notification registration classes, notification classes.
  1290.  
  1291.    * Write more/better random number generators.  Make them conform to
  1292.      the protocol <RandomGenerating>.  See RNGAdditiveCongruential.
  1293.  
  1294.    * Write user-visible random number classes in the spirit of the
  1295.      `Random' class.  Look at Smalltalk's ProbabilityDistribution
  1296.      classes, and think about replacing the `Random' class with
  1297.      something more like these.  How about Poisson and Gaussian
  1298.      distributions also?
  1299.  
  1300. My To Do's
  1301. ==========
  1302.  
  1303.    * Many code fixes and cleanups, indicated with `xxx' in the source.
  1304.  
  1305.    * In remote object messaging, send exceptions back to the requestor.
  1306.      I'm waiting for gcc 2.7 exceptions.
  1307.  
  1308.    * Add Coding methods to all the other collection classes.
  1309.  
  1310.    * Find method for detecting NeXT vs GNU runtime.  Put it in
  1311.      `configure.in' and define `NeXT_runtime'.
  1312.  
  1313.    * The LAMBDA macro doesn't work on all systems.  Request a change to
  1314.      gcc that make something like LAMBDA work on all systems.
  1315.  
  1316.    * Possibly change `-(int)compare:anObject' for Collection.  How
  1317.      should non-Indexed collections be ordered?
  1318.  
  1319.    * Think about restructuring the Collection heirarchy.  We need an
  1320.      abstract class for collections that are ordered, but whose order
  1321.      is fixed by the -compare: method, i.e. not user-settable.  We need
  1322.      non-mutable version of the classes.  The implementation of this
  1323.      stuff is crying out for multiple inheritance or
  1324.      protocols-with-implementation!
  1325.  
  1326.    * Finish HashTable.m.  Implement freeKeys:values: (What is this
  1327.      supposed to do anyway?).  Handle archiving of atom string, "%",
  1328.      keys.
  1329.  
  1330.    * Finish Time.m.  Many methods are not yet implemented.
  1331.  
  1332.    * Write a good hash function for floats and doubles.
  1333.  
  1334.    * Many implementations could be made more efficient.  Libobjects
  1335.      hasn't been efficiency tuned at all.  Overridding more methods in
  1336.      certain classes could make things more efficient (especially
  1337.      EltNodeCollector).  SplayTree's could be done using top-down
  1338.      splaying.  collhash could be completely reimplemented.  ...and a
  1339.      lot more...
  1340.  
  1341.    * Fix bugs that arise when double's are included in the elt union.
  1342.  
  1343.    * Fix all the subclassResponsibility comments in objects/*.h
  1344.  
  1345.    * I will finish libobjects documentation.
  1346.  
  1347. Questions
  1348. =========
  1349.  
  1350.    I would greatly appreciate your feedback on the questions below.
  1351. Please email your thoughts to mccallum@gnu.ai.mit.edu.
  1352.  
  1353.    * I want to put method names in texinfo indices, but the colons in
  1354.      the method names are interfering with info's notion of menu item
  1355.      names and node names.  Help.  Any ideas?  (Kresten?)
  1356.  
  1357.    * I need to read through al the enumState code again and clean it up.
  1358.      Perhaps we'd like an Iterator class to use as a wrapper around the
  1359.      enumState functionality?  The NIH Class Library organizes things
  1360.      this way.
  1361.  
  1362.    * Should we keep the -safe... enumeration methods?  They sure do add
  1363.      a lot of clutter to the protocols.  If we got rid of them people
  1364.      would have to alloc an Array, copy the contents, and free the Array
  1365.      themselves.
  1366.  
  1367.    * What would people think about removing the ...Object methods, and
  1368.      just having the ...Element methods instead?  It might be a bit
  1369.      more difficult to use, but it would reduce clutter significantly.
  1370.      The ...Element methods are more efficient to use anyway, since
  1371.      most ...Object methods are wrappers around ...Element calls.  I'm
  1372.      not sure what I think we should do.
  1373.  
  1374.      Here's an idea: Define the ...Object methods as macros.  But we
  1375.      need a new macro scheme that works for methods instead of
  1376.      functions.  We would need something with the following
  1377.      functionality:
  1378.           #define [REC replaceObject: OLDOBJ with: NEWOBJ] \
  1379.                   ([REC replaceElement:(elt)(OLDOBJ) with:(elt)(NEWOBJ)].id_u)
  1380.      The issue of macros for methods has been mentioned in email found
  1381.      in the gnu-objc-issues archive, in the file `preprocessor'.
  1382.  
  1383.    * It would be nice to have more error checking on the types going in
  1384.      and out of a collection.  When some code tries to put a float into
  1385.      a collector initialized to hold integers, it would be nice to
  1386.      catch that.  Perhaps just some macros that will do the appropriate
  1387.      checks?  It would also be nice if elt's returned from methods were
  1388.      automatically casted to the correct type.
  1389.  
  1390.      It might be good to use something like this (from the gcc PROJECTS
  1391.      file):
  1392.           * A way of defining a structure containing a union, in which the choice
  1393.           of union alternative is controlled by a previous structure component.
  1394.           
  1395.           Here is a possible syntax for this.
  1396.           
  1397.           struct foo {
  1398.             enum { INT, DOUBLE } code;
  1399.             auto union { case INT: int i; case DOUBLE: double d;} value : code;
  1400.           };
  1401.  
  1402.      This has the disadvantage that now elt's will take up more than one
  1403.      word.
  1404.  
  1405.      What I would prefer is something more radical:  Some efficient way
  1406.      to enable int's, float's to receive Objective-C messages.  Then I
  1407.      wouldn't have to worry about any of these horrible elt typing
  1408.      issues; I wouldn't have to worry about all the ...Object
  1409.      ...Element method name duplication; I wouldn't have to worry about
  1410.      the inefficiency of having all the ...Object methods just be
  1411.      covers for the ...Element methods.  Lots of other Objective-C code
  1412.      would find this useful too.  It has the advantage of fixing the
  1413.      previous question also (about removing the ...Element ...Object
  1414.      method duplication).  We need Objective-C objects that can live on
  1415.      the stack.
  1416.  
  1417.      For now, I've worked out a ObjC++ solution to this with
  1418.      constructors and casting operators.  Now I'm just waiting for
  1419.      Kresten to finish ObjC++.
  1420.  
  1421.    * Perhaps we should put more safety checks into LinkedList,
  1422.      BinaryTree, etc:  Check that node is not already part of another
  1423.      collection (by checking that neighbor pointers are nil?)  In method
  1424.      "insertObject:newObject after:oldObject" make sure that oldObject
  1425.      is a member of self.  ...It seems that there is a lot of potential
  1426.      for nasty bugs with mistakes like these.
  1427.  
  1428.    * HashTable.m (-initKeyDesc:valueDesc:capacity:)  I tried to make it
  1429.      portable, but I didn't try very hard.  Anyone want to send in
  1430.      fixes?
  1431.  
  1432.    * I fixed -emptyCopy in all the subclasses, but the -emptyCopy scheme
  1433.      seems pretty fragile.  How about calling -initFoo: inside
  1434.      -emptyCopy?  This way we avoid having yet another method in which
  1435.      instance vars must be initialized to some consistent state.
  1436.      -allocCopy would never even get called.  <<ObjC insiders: This is
  1437.      a less well-expressed version of what we've just been discussing
  1438.      in email.>>
  1439.  
  1440.    * The situation with LinkedListNode and LinkedListEltNode, (and the
  1441.      analagous classes for BinaryTree's and RBTree's) are just crying
  1442.      out for multiple inheritance.  Anyone have ideas that are prettier
  1443.      than my quick fix using #include ?  Anyone have an alternate
  1444.      organization that doesn't need multiple inheritance?
  1445.  
  1446.    * Somes classes, like RBTree, depend on a certain ordering of
  1447.      elements to maintain internal consistency.  How should we define
  1448.      the behavior of methods whose names imply that the user can set
  1449.      the ordering of elements independent of these constraints? (like
  1450.      -appendElement: or -insertElement:atIndex: for instance).  I see
  1451.      three possibilities:
  1452.        1. The methods do what they say.  Give the user the power to
  1453.           override the default ordering.
  1454.  
  1455.        2. The methods do not do what they say, but call addElement:
  1456.           instead.  This lets the class maintain its internal
  1457.           consistency, but it has the potential to be a bit confusing
  1458.           to the user.  What would happen if the user sent a sort
  1459.           message to such a class, for instance?
  1460.  
  1461.        3. The methods trigger a -shouldNotImplement: error.  This
  1462.           solution perhaps best expresses the reality of the situation,
  1463.           but it's a bit strange for a class to signal an error on a
  1464.           method which is in a protocol the class conforms to.
  1465.             Currently I'm using solution #1 (in most classes?).
  1466.  
  1467.    * I created libobjects.texi by copying libg++.texi.  Some of the text
  1468.      is taken verbatim.  Is this a problem?
  1469.  
  1470.    * If you don't like the organization of the documentation and you
  1471.      have suggestions for changes, please say so now, not after it's
  1472.      all been written.
  1473.  
  1474.    * Does anyone really miss the ability to set the comparison function
  1475.      independent of the element encoding?  If it's really important we
  1476.      can come up with ways to do this and still be able to archive
  1477.      comparison functions.
  1478.  
  1479.    * Something like this needed?  - elementDidChange: (elt*)elementPtr;
  1480.      Currently you have to remove, change, add, for some classes.
  1481.  
  1482.    * Opinions on the error reporting scheme?  See also
  1483.      `checks/test05.m'.  This error reporting scheme will most likely
  1484.      change completely as soon as gcc gets exception handling.
  1485.  
  1486.    * Should I include _comparison_function as an instance variable of
  1487.      Collection?  Putting it back in could make some things more
  1488.      efficient, but several classes don't have configurable
  1489.      comparisonFunction's (i.e. String, LinkedList, BinaryTree,
  1490.      RBTree), so they don't need it.
  1491.  
  1492.    * I've been told that GNU filenames should be 14 chars or less.  I
  1493.      don't want to abbreviate my classnames, but I think using .h
  1494.      @interface files with names different than the class name is even
  1495.      worse.  ** I want to keep my unabbreviated filenames!! **  What to
  1496.      do, what to do... I can't believe that *all* GNU classnames will be
  1497.      limited to 12 characters forever and ever--disgusting.
  1498.  
  1499. Changes I'd like in the Objective-C runtime and gcc:
  1500. ====================================================
  1501.  
  1502.    * Make OBJC_MALLOC() and friends public.  Have the runtime and
  1503.      Object.m use them.  See objc-malloc.[hm].
  1504.  
  1505.    * Give hash.[hc] functionality more like collhash.[hc], i.e.: Add
  1506.      hash_node_for_key() to hash.h and hash.c.  Change hash_next() so
  1507.      that more than one enumeration of the contents can happen
  1508.      concurrently.  How about removing cache as a parameter to the
  1509.      hashing functions in hash.h and hash.c.  Do the masking on the
  1510.      result of the hash function.  This seems much neater to me.
  1511.  
  1512.    * Add a way of defining a structure containing a union, in which the
  1513.      choice of union alternative is controlled by a previous structure
  1514.      component.  (See gcc `PROJECTS' file.)
  1515.  
  1516. How to contribute
  1517. =================
  1518.  
  1519.    Programmers who have written Objective-C classes that they believe
  1520. to be of general interest are encouraged to write to
  1521. mccallum@gnu.ai.mit.edu.  Contributing code is not difficult. Here are
  1522. some general guidelines:
  1523.  
  1524.    * FSF must maintain the right to accept or reject potential
  1525.      contributions.  Generally, the only reasons for rejecting
  1526.      contributions are cases where they duplicate existing or
  1527.      nearly-released code, contain unremovable specific machine
  1528.      dependencies, or are somehow incompatible with the rest of the
  1529.      library.
  1530.  
  1531.    * Acceptance of contributions means that the code is accepted for
  1532.      adaptation into libobjects.  FSF must reserve the right to make
  1533.      various editorial changes in code. Very often, this merely entails
  1534.      formatting, maintenance of various conventions, etc. Contributors
  1535.      are always given authorship credit and shown the final version for
  1536.      approval.
  1537.  
  1538.    * Contributors must assign their copyright to FSF via a form sent out
  1539.      upon acceptance. Assigning copyright to FSF ensures that the code
  1540.      may be freely distributed.
  1541.  
  1542.    * Assistance in providing documentation, test files, and debugging
  1543.      support is strongly encouraged.
  1544.  
  1545.    Extensions, comments, and suggested modifications of existing
  1546. libobjects features are also very welcome.
  1547.  
  1548. File: libobjects.info,  Node: Protocol Index,  Next: Class Index,  Prev: Projects,  Up: Top
  1549.  
  1550. Protocol Index
  1551. **************
  1552.  
  1553. * Menu:
  1554. File: libobjects.info,  Node: Class Index,  Next: Method Function Macro Index,  Prev: Protocol Index,  Up: Top
  1555.  
  1556. Class Index
  1557. ***********
  1558.  
  1559. * Menu:
  1560. File: libobjects.info,  Node: Method Function Macro Index,  Next: Concept Index,  Prev: Class Index,  Up: Top
  1561.  
  1562. Method, Function and Macro Index
  1563. ********************************
  1564.  
  1565. * Menu:
  1566.  
  1567. * -exchangeTop on Stack:                Stack Methods.
  1568. * -freeEnumState: on Collection:        Basic Enumerating.
  1569. * -getNextElement:withEnumState: on Collection: Basic Enumerating.
  1570. * -getNextObject:withEnumState: on Collection: Basic Enumerating.
  1571. * -getPrevElement:withEnumState: on IndexedCollection: Indexed Enumerating.
  1572. * -getPrevObject:withEnumState: on IndexedCollection: Indexed Enumerating.
  1573. * -makeObjectsPerformInReverse: on IndexedCollection: Indexed Enumerating.
  1574. * -makeObjectsPerformInReverse:with: on IndexedCollection: Indexed Enumerating.
  1575. * -newEnumState on Collection:          Basic Enumerating.
  1576. * -popElement: on Stack:                Stack Methods.
  1577. * -popObject: on Stack:                 Stack Methods.
  1578. * -pushElement: on Stack:               Stack Methods.
  1579. * -pushObject: on Stack:                Stack Methods.
  1580. * -safeMakeObjectsPerformInReverse: on IndexedCollection: Indexed Enumerating.
  1581. * -safeMakeObjectsPerformInReverse:with: on IndexedCollection: Indexed Enumerating.
  1582. * -safeWithElementsCall:whileTrue: on Collection: Basic Enumerating.
  1583. * -safeWithElementsInReverseCall: on IndexedCollection: Indexed Enumerating.
  1584. * -safeWithElementsInReverseCall:whileTrue: on IndexedCollection: Indexed Enumerating.
  1585. * -safeWithObjectsInReverseCall: on IndexedCollection: Indexed Enumerating.
  1586. * -safeWithObjectsInReverseCall:whileTrue: on IndexedCollection: Indexed Enumerating.
  1587. * -setCapacity: on Array:               Array Capacity Management.
  1588. * -setGrowFactor: on Array:             Array Capacity Management.
  1589. * -topElement on Stack:                 Stack Methods.
  1590. * -topObject on Stack:                  Stack Methods.
  1591. * -withElementsCall:whileTrue: on Collection: Basic Enumerating.
  1592. * -withElementsInReverseCall: on IndexedCollection: Indexed Enumerating.
  1593. * -withElementsInReverseCall:whileTrue: on IndexedCollection: Indexed Enumerating.
  1594. * -withObjectsInReverseCall: on IndexedCollection: Indexed Enumerating.
  1595. * -withObjectsInReverseCall:whileTrue: on IndexedCollection: Indexed Enumerating.
  1596. * +defaultCapacity on Array:            Array Capacity Management.
  1597. * +defaultGrowFactor on Array:          Array Capacity Management.
  1598. * -addContentsOf: on Collection:        Basic Adding.
  1599. * -addContentsOfIfAbsent: on Collection: Basic Adding.
  1600. * -addElement: on Bag:                  Bag Adding.
  1601. * -addElement: on Collection:           Basic Adding.
  1602. * -addElementIfAbsent: on Collection:   Basic Adding.
  1603. * -addElementsCount: on Collection:     Basic Adding.
  1604. * -addObject: on Bag:                   Bag Adding.
  1605. * -addObject: on Collection:            Basic Adding.
  1606. * -addObjectIfAbsent: on Collection:    Basic Adding.
  1607. * -addObjectsCount: on Collection:      Basic Adding.
  1608. * -appendContentsOf: on IndexedCollection: Indexed Adding.
  1609. * -appendElement: on IndexedCollecting: Indexed Adding.
  1610. * -appendObject: on IndexedCollection:  Indexed Adding.
  1611. * -contentEncoding on Collection:       Basic Querying.
  1612. * -initEncoding: on Array:              Array Capacity Management.
  1613. * -initEncoding: on Collection:         Basic Creating.
  1614. * -init on Collection:                  Basic Creating.
  1615. * -insertElement:after: on IndexedCollecting: Indexed Adding.
  1616. * -insertElement:atIndex: on IndexedCollecting: Indexed Adding.
  1617. * -insertElement:atKey: on KeyedCollection: Keyed Adding.
  1618. * -insertElement:before: on IndexedCollecting: Indexed Adding.
  1619. * -insertObject:after: on IndexedCollection: Indexed Adding.
  1620. * -insertObject:atIndex: on IndexedCollection: Indexed Adding.
  1621. * -insertObject:atKey: on KeyedCollection: Keyed Adding.
  1622. * -insertObject:before: on IndexedCollection: Indexed Adding.
  1623. * -isEmpty on Collection:               Basic Querying.
  1624. * -prependContentsOf: on IndexedCollection: Indexed Adding.
  1625. * -prependElement: on IndexedCollecting: Indexed Adding.
  1626. * -prependObject: on IndexedCollection: Indexed Adding.
  1627. * -read: on Collection:                 Archiving.
  1628. * -removeElement: on Bag:               Bag Removing.
  1629. * -removeObject: on Bag:                Bag Removing.
  1630. * -safeWithElementsCall: on Collection: Basic Enumerating.
  1631. * -safeWithObjectsCall: on Collection:  Basic Enumerating.
  1632. * -withElementsCall: on Collection:     Basic Enumerating.
  1633. * -withObjectsCall: on Collection:      Basic Enumerating.
  1634. * -write: on Collection:                Archiving.
  1635. * insertContentsOf:atIndex: on IndexedCollection: Indexed Adding.
  1636. * COLL_GCC_VERSION:                     Conventions.
  1637. * COLL_VERSION:                         Conventions.
  1638. * LAMBDA:                               LAMBDA.
  1639.  
  1640. File: libobjects.info,  Node: Concept Index,  Prev: Method Function Macro Index,  Up: Top
  1641.  
  1642. Concept Index
  1643. *************
  1644.  
  1645. * Menu:
  1646.  
  1647. * Content types:                        Content Types.
  1648. * Defining Functions In Place:          LAMBDA.
  1649. * Function definitions with LAMBDA:     LAMBDA.
  1650. * Types of storable data:               Content Types.
  1651.  
  1652.  
  1653. Tag Table:
  1654. Node: Top1254
  1655. Node: Copying3031
  1656. Node: Contributors3164
  1657. Node: Installation4235
  1658. Node: Trouble10725
  1659. Node: Overview10965
  1660. Node: Organization13490
  1661. Node: Conventions16574
  1662. Node: Content Types20546
  1663. Node: Creating21688
  1664. Node: Basic Creating21871
  1665. Node: Keyed Creating22300
  1666. Node: Freeing22417
  1667. Node: Adding22833
  1668. Node: Basic Adding23067
  1669. Node: Keyed Adding24334
  1670. Node: Indexed Adding24822
  1671. Node: Removing26515
  1672. Node: Basic Removing26764
  1673. Node: Keyed Removing26850
  1674. Node: Indexed Removing26961
  1675. Node: Replacing27082
  1676. Node: Basic Replacing27315
  1677. Node: Keyed Replacing27404
  1678. Node: Indexed Replacing27519
  1679. Node: Enumerating27643
  1680. Node: Safe vs Unsafe Enumerating28802
  1681. Node: Basic Enumerating29376
  1682. Node: Keyed Enumerating31130
  1683. Node: Indexed Enumerating31290
  1684. Node: LAMBDA32896
  1685. Node: Duplicating35591
  1686. Node: Archiving35782
  1687. Node: Querying36223
  1688. Node: Basic Querying36430
  1689. Node: Keyed Querying36909
  1690. Node: Indexed Querying37051
  1691. Node: Sorting37174
  1692. Node: Classes37308
  1693. Node: Set37849
  1694. Node: Bag37954
  1695. Node: Bag Adding38374
  1696. Node: Bag Removing38625
  1697. Node: Dictionary38897
  1698. Node: MappedCollector39038
  1699. Node: Array39196
  1700. Node: Array Capacity Management39722
  1701. Node: Stack40140
  1702. Node: Stack Methods40654
  1703. Node: Queue41009
  1704. Node: GapArray41093
  1705. Node: LinkedList41182
  1706. Node: BinaryTree41276
  1707. Node: RBTree41368
  1708. Node: SplayTree41459
  1709. Node: EltNodeCollector41556
  1710. Node: Collection41657
  1711. Node: KeyedCollection41956
  1712. Node: IndexedCollection42381
  1713. Node: Projects42879
  1714. Node: Protocol Index56752
  1715. Node: Class Index56886
  1716. Node: Method Function Macro Index57033
  1717. Node: Concept Index61694
  1718. End Tag Table
  1719.